﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using reformat.contracts;

namespace reformat
{
    class Reformat 
        : contracts.ILeseDateiEin, 
        contracts.IFormatieren, 
        contracts.ISchreibeZeilenweise,
        contracts.IAufteilenInWorteAnWhitespace, 
        contracts.IZeilenBauen {
        
        public static int Process(string[] p_Args) {
            try {
                string dateiinhalt =  LeseDateiEin(p_Args[0]);
                IEnumerable <string> zeilen = Formatieren(dateiinhalt, int.Parse(p_Args[2]));
                return SchreibeZeilenweise( zeilen, p_Args[1]);
            }
            catch (Exception) {
                return (-1);
            }
        }

        public static String[] Whitespaces {
            get {
                return new string[] { " ", "\n", "\f", "\r", "\t", "\v" };
            } 
        }

        internal static string LeseDateiEin(string p_Eingangsdateinname) {
            try {
                var file = new StreamReader(p_Eingangsdateinname, Encoding.ASCII);
                string alles = file.ReadToEnd() ;
                file.Close();
                return alles;
            }
            catch (Exception) {
                return String.Empty;
            }
        }
        
        internal static IEnumerable<string> Formatieren(string p_Dateiinhalt, int p_Zeilenlaenge) {
            return ZeilenBauen(
                        AufteilenInWorteAnWhitespace(p_Dateiinhalt),
                        p_Zeilenlaenge);
        }

        internal static int SchreibeZeilenweise(IEnumerable<string> p_Zeilen, string p_Ausgangssdateinname) {
            StreamWriter writer = null;
            try {
                writer = new StreamWriter(
                    p_Ausgangssdateinname,
                    false,
                    Encoding.ASCII);

                foreach (string zeile in p_Zeilen) {
                    writer.WriteLine(zeile);
                }
                return 0;
            }
            catch (Exception) {
                return -1;
            }
            finally {
                if (writer != null) writer.Close();
            }
        }

         internal static IEnumerable<string> AufteilenInWorteAnWhitespace(string p_Dateiinhalt) {
             try {
                 return p_Dateiinhalt.Split(Whitespaces, StringSplitOptions.None);
                 // return Regex.Split(p_Dateiinhalt,  @"\s+");
                 // return Regex.Split(p_Dateiinhalt, @"\w+|""[\w\s]*""");
                 // return Regex.Split(p_Dateiinhalt, "[^"]+"|\s?\w+?\s" );
                 //return Regex.Split(
                 //                   p_Dateiinhalt,
                 //                   @"((""((?<token>.*?)(?<!\\)"")|(?<token>[\w]+))(\s)*)");
             }
             catch (Exception) {
                 return new List<string>();
             }
             

             //return Regex.Split(
             //                   p_Dateiinhalt,
             //                   @"\W+");


             //List<string> lst;

             //lst = p_Dateiinhalt.Split(Syst)

             //return lst;
         }

         public static IEnumerable<string> ZeilenBauen(IEnumerable<string> p_Worte, int p_Zeilenlaenge) {
             List<string> zeilen = new List<string>();
             string zeile = string.Empty;

             foreach (string wort in p_Worte ) {
                if (zeile.Length + wort.Length < p_Zeilenlaenge) {
                    zeile = string.Join(" ", zeile, wort);
                } else {
                    zeilen.Add(zeile);
                    zeile = wort;
                }
             }
             zeilen.Add(zeile);

             return zeilen;
         }





        string ILeseDateiEin.Process(string p_Eingangsdateinname)
        {
            return LeseDateiEin(p_Eingangsdateinname);
        }

        IEnumerable<string> IFormatieren.Process(string p_Dateiinhalt, int p_Zeilenlaenge)
        {
            return Formatieren(p_Dateiinhalt, p_Zeilenlaenge);
        }

        public int Process(IEnumerable<string> p_Zeilen, string p_Ausgangssdateinname)
        {
            throw new NotImplementedException();
        }

        public IEnumerable<string> Process(IEnumerable<string> p_Worte, int p_Zeilenlaenge)
        {
            throw new NotImplementedException();
        }

        IEnumerable<string> IAufteilenInWorteAnWhitespace.Process(string p_Dateiinhalt)
        {
            throw new NotImplementedException();
        }
    }
}
